
/**
 * 显示返回顶部按钮，开始、结束、运动 三个过程中调用函数判断是否达到目标点
 */
export const ShowBack = callback => {
  let requestFram
  let oldScrollTop

  document.addEventListener('scroll', () => {
    showBackFun()
  }, false)
  document.addEventListener('touchstart', () => {
    showBackFun()
  }, {
    passive: true
  })

  document.addEventListener('touchmove', () => {
    showBackFun()
  }, {
    passive: true
  })

  document.addEventListener('touchend', () => {
    oldScrollTop = document.body.scrollTop
    moveEnd()
  }, {
    passive: true
  })

  const moveEnd = () => {
    requestFram = requestAnimationFrame(() => {
      if (document.body.scrollTop !== oldScrollTop) {
        oldScrollTop = document.body.scrollTop
        moveEnd()
      } else {
        cancelAnimationFrame(requestFram)
      }
      showBackFun()
    })
  }

  // 判断是否达到目标点
  const showBackFun = () => {
    if (document.body.scrollTop > 500) {
      callback(true)
    } else {
      callback(false)
    }
  }
}
/**
 * 获取style样式
 */
export const GetStyle = (element, attr, NumberMode = 'int') => {
  let target
  // scrollTop 获取方式不同，没有它不属于style，而且只有document.body才能用
  if (attr === 'scrollTop') {
    target = element.scrollTop
  } else if (element.currentStyle) {
    target = element.currentStyle[attr]
  } else {
    target = document.defaultView.getComputedStyle(element, null)[attr]
  }
  // 在获取 opactiy 时需要获取小数 parseFloat
  return NumberMode === 'float' ? parseFloat(target) : parseInt(target)
}

/**
 * 运动效果
 * @param {HTMLElement} element   运动对象，必选
 * @param {JSON}        target    属性：目标值，必选
 * @param {number}      duration  运动时间，可选
 * @param {string}      mode      运动模式，可选
 * @param {function}    callback  可选，回调函数，链式动画
 */
export const Animate = (element, target, duration = 400, mode = 'ease-out', callback) => {
  clearInterval(element.timer)

  // 判断不同参数的情况
  if (duration instanceof Function) {
    callback = duration
    duration = 400
  } else if (duration instanceof String) {
    mode = duration
    duration = 400
  }

  // 判断不同参数的情况
  if (mode instanceof Function) {
    callback = mode
    mode = 'ease-out'
  }

  // 获取dom样式
  const attrStyle = attr => {
    if (attr === 'opacity') {
      return Math.round(GetStyle(element, attr, 'float') * 100)
    } else {
      return GetStyle(element, attr)
    }
  }
  // 根字体大小，需要从此将 rem 改成 px 进行运算
  const rootSize = parseFloat(document.documentElement.style.fontSize)

  const unit = {}
  const initState = {}

  // 获取目标属性单位和初始样式值
  Object.keys(target).forEach(attr => {
    if (/[^\d^\\.]+/gi.test(target[attr])) {
      unit[attr] = target[attr].match(/[^\d^\\.]+/gi)[0] || 'px'
    } else {
      unit[attr] = 'px'
    }
    initState[attr] = attrStyle(attr)
  })

  // 去掉传入的后缀单位
  Object.keys(target).forEach(attr => {
    if (unit[attr] === 'rem') {
      target[attr] = Math.ceil(parseInt(target[attr]) * rootSize)
    } else {
      target[attr] = parseInt(target[attr])
    }
  })

  let flag = true // 假设所有运动到达终点
  const remberSpeed = {} // 记录上一个速度值,在ease-in模式下需要用到
  element.timer = setInterval(() => {
    Object.keys(target).forEach(attr => {
      let iSpeed = 0 // 步长
      let status = false // 是否仍需运动
      let iCurrent = attrStyle(attr) || 0 // 当前元素属性址
      let speedBase = 0 // 目标点需要减去的基础值，三种运动状态的值都不同
      let intervalTime // 将目标值分为多少步执行，数值越大，步长越小，运动时间越长
      switch (mode) {
        case 'ease-out':
          speedBase = iCurrent
          intervalTime = duration * 5 / 400
          break
        case 'linear':
          speedBase = initState[attr]
          intervalTime = duration * 20 / 400
          break
        case 'ease-in':
          let oldspeed = remberSpeed[attr] || 0
          iSpeed = oldspeed + (target[attr] - initState[attr]) / duration
          remberSpeed[attr] = iSpeed
          break
        default:
          speedBase = iCurrent
          intervalTime = duration * 5 / 400
      }
      if (mode !== 'ease-in') {
        iSpeed = (target[attr] - speedBase) / intervalTime
        iSpeed = iSpeed > 0 ? Math.ceil(iSpeed) : Math.floor(iSpeed)
      }
      // 判断是否达步长之内的误差距离，如果到达说明到达目标点
      switch (mode) {
        case 'ease-out':
          status = iCurrent !== target[attr]
          break
        case 'linear':
          status = Math.abs(Math.abs(iCurrent) - Math.abs(target[attr])) > Math.abs(iSpeed)
          break
        case 'ease-in':
          status = Math.abs(Math.abs(iCurrent) - Math.abs(target[attr])) > Math.abs(iSpeed)
          break
        default:
          status = iCurrent !== target[attr]
      }

      if (status) {
        flag = false
        // opacity 和 scrollTop 需要特殊处理
        if (attr === 'opacity') {
          element.style.filter = 'alpha(opacity:' + (iCurrent + iSpeed) + ')'
          element.style.opacity = (iCurrent + iSpeed) / 100
        } else if (attr === 'scrollTop') {
          element.scrollTop = iCurrent + iSpeed
        } else {
          element.style[attr] = iCurrent + iSpeed + 'px'
        }
      } else {
        flag = true
      }

      if (flag) {
        clearInterval(element.timer)
        if (callback) {
          callback()
        }
      }
    })
  }, 20)
}

/**
 * 联系客服demo，点击跳转：
   import ysf from '../../plugins/qiyukf'
   import { qiyukf } from '../../config/utils'
   methods: {
     linkCustomService () {
       qiyukf()
     }
   }
   用户ID，localStorage存在了verify | se-password | empty-page | bind-phone
 */
export function qiyukf () {
  // 拿到用户登录之后的用户名和手机号码
  var userName = localStorage.getItem('userName')
  var telphone = localStorage.getItem('telphone')
  var userId = localStorage.getItem('userId')

  // 必填项：用户名、电话
  var namePhone = {
    uid: userId,  // 必填，拿登录之后的用户id
    email: '', // 非必填
    name: userName, // *必填，用户名
    mobile: telphone // *必填，电话
  }

  // 配置用户信息
  window.ysf.config(namePhone)
  console.log('namePhone ', namePhone)
  location.href = window.ysf.url()
}

/**
 * 校验是否合法手机号
 * @param  {[type]} phone [description]
 * @return {[type]}       [description]
 */
export const checkPhone = (phone) => {
  if (/^1[34578]\d{9}$/.test(phone)) {
    return true
  } else {
    return false
  }
}

/**
 * 获取 url 参数
 * @param  {[type]} name [description]
 * @param  {[type]} link [description]
 * @return {[type]}      [description]
 */
export const getUrlKey = (name, link = location.href) => {
  const reg = new RegExp(`(?:^|&)${name}=([^&]*)(?:&|$)`)
  const r = link.substring(link.indexOf('?') + 1).match(reg)
  if (r) {
    return decodeURIComponent(r[1])
  }
  return ''
}

/**
 * 获取渠道号
 */
export const getChannelCode = () => {
  var channelCode = getUrlKey('channel')

  if (!channelCode) {
    channelCode = localStorage.getItem('channelCode')
  } else {
    localStorage.setItem('channelCode', channelCode)
  }
  // console.log('channelCode', channelCode)
  return channelCode
}

/**
 * 时间格式化
 * @param  {[type]} time   [description]
 * @param  {[type]} format [description]
 * @return {[type]}        [description]
 */
export const formatTimeString = (time, format) => {
  var format1 = format1 || 'yyyy-MM-dd'
  var t = new Date(time)
  var tf = function (i) {
    return (i < 10 ? '0' : '') + i
  }
  return format1.replace(/yyyy|MM|dd|HH|mm|ss/g, function (a) {
    switch (a) {
      case 'yyyy':
        return tf(t.getFullYear())
      case 'MM':
        return tf(t.getMonth() + 1)
      case 'mm':
        return tf(t.getMinutes())
      case 'dd':
        return tf(t.getDate())
      case 'HH':
        return tf(t.getHours())
      case 'ss':
        return tf(t.getSeconds())
    }
  })
}

/**
 * 跳转登录，登录完再回来
 */
export const goLogin = (url = location.href) => {
  location.href = `/src/views/verify.vue?redirect=${encodeURIComponent(url)}`
}

/**
 * 检查是否已经登录，未登录做登录拦截跳转
 * 即，是否有缓存，是否在登录的时候设置了缓存
 */
// export const isLogin = () => {
//   let currentUser = getCache ({
//     key: 'currentUser',
//     type: 'sessionStorage'
//   })
//   if (currentUser) {
//     return true
//   } else {
//     return false
//   }
// }

/**
 * 设置缓存
 * setCache({
 *     type: 'sessionStorage',
 *     key: 'cache-key-demo',
 *     value: cacheValue
 * })
 */
// export const setCache = (options) => {
//   const type = options.type || 'sessionStorage' // 缓存方式，sessionStorage或localStorage
//   const key = options.key // 缓存的key
//   const dataType = options.dataType || 'json' // 缓存的数据类型，string或json
//   let value = options.value // 缓存的值
//   const time = options.time // 缓存时间,以毫秒为单位
//   if (dataType === 'json') {
//     value = JSON.stringify(value)
//   }
//   let cacheType // 缓存类型,sessionStorage或localStorage
//   if (type === 'sessionStorage') {
//     cacheType = sessionStorage
//   } else if (type === 'localStorage') {
//     cacheType = localStorage
//   } else {
//     return false
//   }
//   try {
//     cacheType.setItem(key, value)
//   } catch (e) {
//     cacheType.clear()
//     cacheType.setItem(key, value)
//   }
//   if (time) { // 如果有设置缓存时间则时间到后数据就会销毁，默认是sessionStorage或localStorage的生命周期
//     const dateTime = new Date()
//     const timeStamp = dateTime.getTime() + time
//     try {
//       sessionStorage.setItem(`${key}-time`, timeStamp)
//     } catch (e) {
//       sessionStorage.clear()
//       sessionStorage.setItem(`${key}-time`, timeStamp)
//     }
//   }
//   return true
// }

/**
 * 获取缓存
 * let cacheValue = getCache({
 *     type: 'sessionStorage',
 *     key: 'cache-key-demo'
 * })
 */
// export const getCache = (options) => {
//   // console.log(options)
//   const key = options.key
//   const type = options.type || 'sessionStorage'
//   const dataType = options.dataType || 'json' // 缓存的数据类型，string或json
//   let cacheType // 缓存类型,sessionStorage或localStorage
//   if (type === 'sessionStorage') {
//     cacheType = sessionStorage
//   } else if (type === 'localStorage') {
//     cacheType = localStorage
//   } else {
//     return false
//   }
//   const dateTime = new Date()
//   const timeStamp = dateTime.getTime()
//   const efficientTime = sessionStorage.getItem(`${key}-time`) || timeStamp + 1000 * 60 * 60 * 24 * 365 // 默认存储时间为1年
//   const timeInterval = efficientTime - timeStamp
//   if (timeInterval >= 0) {
//     let value = cacheType.getItem(key)
//     if (!value) {
//       return false
//     }
//     if (dataType === 'json') {
//       try {
//         value = JSON.parse(cacheType.getItem(key))
//         if (typeof (value) === 'object' && Object.prototype.toString.call(value).toLowerCase() === '[object object]' && !value.length) {
//           value.expiredTime = new Date(parseInt(efficientTime, 10))
//         }
//       } catch (e) {
//         console.log(e)
//       }
//     }
//     return value
//   } else { // 已过缓存时间，让数据失效
//     cacheType.removeItem(key)
//     return false
//   }
// }

/**
 * 获取缓存key
 */
// export const getCacheKey = (url, params) => {
//   if (typeof params === 'undefined') {
//     return url
//   }
//   if (typeof params === 'object') {
//     var tmp = params
//     params = ''
//     $.each(tmp, function(k, v) {
//       params += '&' + k + '=' + v
//     })
//     tmp = null
//   }
//   if (typeof params === 'string') {
//     url += url.indexOf('?') > -1 ? '&' + params : '?' + params
//   }
//   return url
// }

/**
 * 清除缓存
 * @param  {[type]} options [description]
 * @return {[type]}         [description]
 */
// export const clearCache = (options) => {
//   // console.log(options)
//   const key = options.key
//   const type = options.type || 'sessionStorage'
//   // const dataType = options.dataType || 'json' // 缓存的数据类型，string或json
//   let cacheType // 缓存类型,sessionStorage或localStorage
//   if (type === 'sessionStorage') {
//     cacheType = sessionStorage
//   } else if (type === 'localStorage') {
//     cacheType = localStorage
//   } else {
//     return false
//   }
//   cacheType.removeItem(key)
// }
